Java Technologies Vertex এবং Fragment Shader তৈরি করা গাইড ও নোট

JOGL (Java OpenGL) হল Java এ 3D গ্রাফিক্স এবং গেম ডেভেলপমেন্টের জন্য একটি লাইব্রেরি, যা OpenGL গ্রাফিক্স API এর Java বাইন্ডিং হিসেবে কাজ করে। Vertex Shader এবং Fragment Shader হল OpenGL এর দুটি গুরুত্বপূর্ণ শেডার, যেগুলি গ্রাফিক্স রেন্ডারিং প্রক্রিয়ার মূল উপাদান।

• Vertex Shader: এটি গ্রাফিক্স পাইপলাইনের প্রথম শেডার, যা ভেক্টরের অবস্থান নির্ধারণ করে এবং মডেল, ভিউ এবং প্রজেকশন ম্যাট্রিক্সগুলির মাধ্যমে অবজেক্টকে স্থানান্তরিত বা রোটেট করে।
• Fragment Shader: এটি রেন্ডারিং প্রক্রিয়ার পরবর্তী স্তর, যেখানে পিক্সেল রঙ (Color) হিসাব করা হয়, টেক্সচারিং এবং আলোর প্রভাব প্রয়োগ করা হয়।

Vertex Shader এবং Fragment Shader কী?

• Vertex Shader: এটি ইনপুট হিসেবে একটি ভেক্টর নেয় এবং ভেক্টরের গঠন বা অবস্থান পরিবর্তন করে। এটি মডেলটিকে পরবর্তী স্তরের শেডারে পাঠানোর জন্য প্রস্তুত করে।
• Fragment Shader: এটি পিক্সেল স্তরের শেডার, যা দৃশ্যের প্রতিটি পিক্সেল (ফ্র্যাগমেন্ট) এর জন্য রঙ তৈরি করে। এটি আলোর প্রভাব, টেক্সচারিং, এবং অন্যান্য পিক্সেল সম্পর্কিত অপারেশনস পরিচালনা করে।

Vertex Shader এবং Fragment Shader তৈরি করার উদাহরণ

এই উদাহরণে, আমরা JOGL ব্যবহার করে একটি basic vertex এবং fragment shader তৈরি করব। এখানে একটি সরল কিউব আঁকার জন্য আমরা শেডার ব্যবহার করব, যেখানে vertex শেডার দ্বারা কিউবের অবস্থান রূপান্তরিত হবে এবং fragment শেডার দ্বারা কিউবের রঙ নির্ধারিত হবে।

Step 1: Vertex Shader এবং Fragment Shader কোড

Vertex Shader (vertex_shader.glsl):

#version 330 core

layout(location = 0) in vec3 position;  // Vertex position
layout(location = 1) in vec3 color;     // Vertex color

out vec3 fragColor; // Color to pass to fragment shader

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main()
{
    gl_Position = projection * view * model * vec4(position, 1.0);  // Apply transformations
    fragColor = color;  // Pass color to fragment shader
}

Fragment Shader (fragment_shader.glsl):

#version 330 core

in vec3 fragColor;  // Color received from vertex shader

out vec4 color;  // Final color output

void main()
{
    color = vec4(fragColor, 1.0);  // Set the final color
}

Step 2: JOGL কোড ব্যবহার করে শেডার কম্পাইল এবং রেন্ডারিং

এখন, JOGL কোড ব্যবহার করে এই শেডার দুটি প্রোগ্রামে অন্তর্ভুক্ত করব এবং OpenGL এর মাধ্যমে কিউব রেন্ডার করব। আমরা কিউবের জন্য 3D model, view, এবং projection ম্যাট্রিক্স ব্যবহার করব।

import com.jogamp.opengl.*;
import com.jogamp.opengl.awt.GLCanvas;
import javax.swing.*;
import javax.media.opengl.GL2;
import com.jogamp.opengl.util.GLBuffers;
import com.jogamp.opengl.util.glsl.ShaderProgram;
import java.nio.FloatBuffer;

public class ShaderExample implements GLEventListener {

    private ShaderProgram shaderProgram;
    private int vao, vbo, ebo;
    
    // Vertex data (positions and colors for a cube)
    private float[] vertices = {
        // Positions         // Colors
        -0.5f, -0.5f,  0.5f, 1.0f, 0.0f, 0.0f,  // Red
         0.5f, -0.5f,  0.5f, 0.0f, 1.0f, 0.0f,  // Green
         0.5f,  0.5f,  0.5f, 0.0f, 0.0f, 1.0f,  // Blue
        -0.5f,  0.5f,  0.5f, 1.0f, 1.0f, 0.0f,  // Yellow
        -0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 1.0f,  // Purple
         0.5f, -0.5f, -0.5f, 0.0f, 1.0f, 1.0f,  // Cyan
         0.5f,  0.5f, -0.5f, 1.0f, 1.0f, 1.0f,  // White
        -0.5f,  0.5f, -0.5f, 0.5f, 0.5f, 0.5f   // Grey
    };

    private int[] indices = {
        0, 1, 2, 2, 3, 0,  // Front face
        4, 5, 6, 6, 7, 4,  // Back face
        0, 1, 5, 5, 4, 0,  // Bottom face
        1, 2, 6, 6, 5, 1,  // Right face
        2, 3, 7, 7, 6, 2,  // Top face
        3, 0, 4, 4, 7, 3   // Left face
    };

    @Override
    public void init(GLAutoDrawable drawable) {
        GL2 gl = drawable.getGL().getGL2();
        
        // Load and compile shaders
        shaderProgram = new ShaderProgram();
        shaderProgram.add("vertex_shader.glsl", ShaderProgram.Type.VERTEX);
        shaderProgram.add("fragment_shader.glsl", ShaderProgram.Type.FRAGMENT);
        shaderProgram.link();
        
        // Set up vertex array object, vertex buffer object, and element buffer object
        vao = gl.glGenVertexArrays();
        gl.glBindVertexArray(vao);

        vbo = gl.glGenBuffers();
        gl.glBindBuffer(GL2.GL_ARRAY_BUFFER, vbo);
        FloatBuffer buffer = GLBuffers.newDirectFloatBuffer(vertices);
        gl.glBufferData(GL2.GL_ARRAY_BUFFER, buffer.limit() * Float.BYTES, buffer, GL2.GL_STATIC_DRAW);

        ebo = gl.glGenBuffers();
        gl.glBindBuffer(GL2.GL_ELEMENT_ARRAY_BUFFER, ebo);
        gl.glBufferData(GL2.GL_ELEMENT_ARRAY_BUFFER, indices.length * Integer.BYTES, GLBuffers.newDirectIntBuffer(indices), GL2.GL_STATIC_DRAW);
        
        // Position attribute
        gl.glVertexAttribPointer(0, 3, GL2.GL_FLOAT, false, 6 * Float.BYTES, 0);
        gl.glEnableVertexAttribArray(0);
        
        // Color attribute
        gl.glVertexAttribPointer(1, 3, GL2.GL_FLOAT, false, 6 * Float.BYTES, 3 * Float.BYTES);
        gl.glEnableVertexAttribArray(1);
        
        // Unbind
        gl.glBindVertexArray(0);
    }

    @Override
    public void display(GLAutoDrawable drawable) {
        GL2 gl = drawable.getGL().getGL2();
        
        gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);  // Clear the canvas
        
        gl.glUseProgram(shaderProgram.getProgramID());  // Use the compiled shader program

        // Set transformation matrices
        int modelLoc = gl.glGetUniformLocation(shaderProgram.getProgramID(), "model");
        int viewLoc = gl.glGetUniformLocation(shaderProgram.getProgramID(), "view");
        int projLoc = gl.glGetUniformLocation(shaderProgram.getProgramID(), "projection");

        // Set matrices
        float[] model = new float[16];
        float[] view = new float[16];
        float[] projection = new float[16];
        
        // Identity matrices for now
        java.util.Arrays.fill(model, 0.0f);
        model[0] = 1.0f;
        model[5] = 1.0f;
        model[10] = 1.0f;
        model[15] = 1.0f;

        java.util.Arrays.fill(view, 0.0f);
        view[0] = 1.0f;
        view[5] = 1.0f;
        view[10] = 1.0f;
        view[15] = 1.0f;

        java.util.Arrays.fill(projection, 0.0f);
        projection[0] = 1.0f;
        projection[5] = 1.0f;
        projection[10] = 1.0f;
        projection[15] = 1.0f;

        gl.glUniformMatrix4fv(modelLoc, 1, false, model, 0);
        gl.glUniformMatrix4fv(viewLoc, 1, false, view, 0);
        gl.glUniformMatrix4fv(projLoc, 1, false, projection, 0);

        // Bind VAO and draw elements (cube)
        gl.glBindVertexArray(vao);
        gl.glDrawElements(GL2.GL_TRIANGLES, indices.length, GL2.GL_UNSIGNED_INT, 0);
        
        gl.glBindVertexArray(0);
    }

    @Override
    public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
        GL2 gl = drawable.getGL().getGL2();
        gl.glViewport(0, 0, width, height);
    }

    @Override
    public void dispose(GLAutoDrawable drawable) {
        // Cleanup
    }

    public static void main(String[] args) {
        // Set up OpenGL canvas and window
        GLCanvas canvas = new GLCanvas();
        canvas.addGLEventListener(new ShaderExample());
        
        JFrame frame = new JFrame("JOGL Shader Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(canvas);
        frame.setSize(800, 600);
        frame.setVisible(true);
    }
}

ব্যাখ্যা:

• Vertex Shader এবং Fragment Shader সৃষ্টির জন্য GLSL কোড ব্যবহার করা হয়েছে। এই শেডারগুলি আমাদের গ্রাফিক্সের অবস্থান রূপান্তর এবং রঙের কার্যাবলী প্রক্রিয়া করবে।
• Vertex Buffer Object (VBO) এবং Element Buffer Object (EBO) ব্যবহার করে কিউবের ভেক্টর ও ইনডেক্স ডেটা শেডারকে পাঠানো হচ্ছে।
• ShaderProgram ব্যবহার করে আমরা শেডার কোড কম্পাইল, লিঙ্ক, এবং শেডার প্রোগ্রাম চালু করেছি।

সারাংশ

JOGL তে Vertex Shader এবং Fragment Shader ব্যবহার করে 3D গ্রাফিক্সের রেন্ডারিং এর ক্ষমতা বৃদ্ধি করা সম্ভব। Vertex Shader অবজেক্টের অবস্থান রূপান্তর এবং Fragment Shader অবজেক্টের রঙ এবং আলো নিয়ন্ত্রণে সহায়ক। OpenGL এবং JOGL এর মাধ্যমে আপনি আরও উন্নত গ্রাফিক্স, আলোর প্রভাব এবং টেক্সচারিং ব্যবহার করে বাস্তবসম্মত দৃশ্য তৈরি করতে পারেন।